{
 "cells": [
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# ViT论文复现\n",
    "\n",
    "> [An Image is Worth 16x16 Words: Transformers for Image Recognition at Scale]([https://arxiv.org/pdf/2010.11929)"
   ],
   "id": "543ae99c8a57c5e5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T23:31:24.663006Z",
     "start_time": "2024-08-21T23:31:23.481723Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import torch\n",
    "from torch import nn\n",
    "\n",
    "import torchvision\n",
    "from torchvision import transforms\n",
    "\n",
    "from torchinfo import summary\n",
    "\n",
    "import data_setup, engine\n",
    "from helper_functions import download_data, set_seeds, plot_loss_curves"
   ],
   "id": "c1e2d9acf1fb2d61",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:03:54.386501Z",
     "start_time": "2024-08-21T13:03:54.371503Z"
    }
   },
   "cell_type": "code",
   "source": [
    "device = torch.device(\"cuda:7\" if torch.cuda.is_available() else \"cpu\") # 指明调用的GPU为7号\n",
    "device"
   ],
   "id": "54122ed269ee3407",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "device(type='cuda', index=7)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## 关注图1、表、公式\n",
    "\n",
    "![](./assets/ViT.png)\n",
    "\n",
    "![](./assets/ViT_eq.png)\n",
    "\n",
    "![](./assets/ViT_tab.png)\n",
    "\n",
    "![](./assets/ViT_HyperParams.png)\n",
    "\n",
    "# 根据架构图和数学公式写代码\n",
    "\n",
    "## eq.1-embedding 嵌入\n",
    "\n",
    "> an embedding is a learnable representation of some form and is often a vector.  \n",
    "> **learnable** is important because this means the numerical representation of an input image (that the model sees) can be improved over time.\n",
    "\n",
    "\n",
    "$$ \\begin{aligned} \\mathbf{z}_{0} &=\\left[\\mathbf{x}_{\\text {class }} ; \\mathbf{x}_{p}^{1} \\mathbf{E} ; \\mathbf{x}_{p}^{2} \\mathbf{E} ; \\cdots ; \\mathbf{x}_{p}^{N} \\mathbf{E}\\right]+\\mathbf{E}_{\\text {pos }}, & & \\mathbf{E} \\in \\mathbb{R}^{\\left(P^{2} \\cdot C\\right) \\times D}, \\mathbf{E}_{\\text {pos }} \\in \\mathbb{R}^{(N+1) \\times D} \\end{aligned} $$\n",
    "\n",
    "\n",
    "```python\n",
    "x_input = [class_token, image_patch_1, image_patch_2, image_patch_3] \\\n",
    "        + [class_token_position, image_patch_1_position, image_patch_2_position, image_patch_3_position]\n",
    "```"
   ],
   "id": "86a719c3d3d543c1"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:04:16.064049Z",
     "start_time": "2024-08-21T13:04:16.049050Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Transformer采用常数隐向量（D维）和线性映射（即 patch embedding）\n",
    "# 由表3知，输入图像的分辨率为224，即 H = W = 224，通道 C = 3\n",
    "height = 224 # H \n",
    "width = 224 # W\n",
    "color_channels = 3 # C\n",
    "# 由表5知，ViT-B/16，即patch_size = 16 时，性能比ViT-B/32好\n",
    "patch_size = 16 # P\n",
    "# 由文章第3.1节得关系：(H, W, C) -> (N_Patches, P^2·C) 其中 N = HW/P^2 = 196，嵌入维度为768\n",
    "number_of_patches = int((height * width) / patch_size**2) # N (number of patches)\n",
    "\n",
    "print(f\"Number of patches (N) with image height (H={height}), width (W={width}) and patch size (P={patch_size}): {number_of_patches}\")"
   ],
   "id": "811cd4518ddfbed8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of patches (N) with image height (H=224), width (W=224) and patch size (P=16): 196\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 确定输入、输出维度",
   "id": "2e12284c311206f9"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:04:19.635154Z",
     "start_time": "2024-08-21T13:04:19.622157Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Input shape (this is the size of a single image)\n",
    "embedding_layer_input_shape = (height, width, color_channels)\n",
    "# Output shape\n",
    "embedding_layer_output_shape = (number_of_patches, patch_size**2 * color_channels)\n",
    "\n",
    "print(f\"Input shape (single 2D image): {embedding_layer_input_shape}\")\n",
    "print(f\"Output shape (single 2D image flattened into patches): {embedding_layer_output_shape}\")"
   ],
   "id": "507e655068739325",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input shape (single 2D image): (224, 224, 3)\n",
      "Output shape (single 2D image flattened into patches): (196, 768)\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 准备数据",
   "id": "7c77162ed8d41673"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:04:23.093017Z",
     "start_time": "2024-08-21T13:04:23.070904Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Download pizza, steak, sushi images from GitHub\n",
    "image_path = download_data(source=\"https://github.com/mrdbourke/pytorch-deep-learning/raw/main/data/pizza_steak_sushi.zip\",\n",
    "                           destination=\"pizza_steak_sushi\")\n",
    "image_path"
   ],
   "id": "91ca145654bf9089",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[INFO] data\\pizza_steak_sushi directory exists, skipping download.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "WindowsPath('data/pizza_steak_sushi')"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:04:31.003627Z",
     "start_time": "2024-08-21T13:04:30.979632Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Setup directory paths to train and test images\n",
    "train_dir = image_path / \"train\"\n",
    "test_dir = image_path / \"test\"\n",
    "# Create image size (from Table 3 in the ViT paper)\n",
    "IMG_SIZE = 224\n",
    "\n",
    "# Create transform pipeline manually\n",
    "manual_transforms = transforms.Compose([\n",
    "    transforms.Resize((IMG_SIZE, IMG_SIZE)),\n",
    "    transforms.ToTensor(),\n",
    "])\n",
    "print(f\"Manually created transforms: {manual_transforms}\")\n",
    "\n",
    "# Set the batch size\n",
    "BATCH_SIZE = 32 # this is lower than the ViT paper but it's because we're starting small\n",
    "\n",
    "# Create data loaders\n",
    "train_dataloader, test_dataloader, class_names = data_setup.create_dataloaders(\n",
    "    train_dir=train_dir,\n",
    "    test_dir=test_dir,\n",
    "    transform=manual_transforms, # use manually created transforms\n",
    "    batch_size=BATCH_SIZE\n",
    ")\n",
    "\n",
    "train_dataloader, test_dataloader, class_names"
   ],
   "id": "e6ba879d0546d54b",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Manually created transforms: Compose(\n",
      "    Resize(size=(224, 224), interpolation=bilinear, max_size=None, antialias=True)\n",
      "    ToTensor()\n",
      ")\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(<torch.utils.data.dataloader.DataLoader at 0x280e08b3220>,\n",
       " <torch.utils.data.dataloader.DataLoader at 0x280a34c6be0>,\n",
       " ['pizza', 'steak', 'sushi'])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:04:40.062618Z",
     "start_time": "2024-08-21T13:04:39.505859Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Get a batch of images\n",
    "image_batch, label_batch = next(iter(train_dataloader))\n",
    "\n",
    "# Get a single image from the batch\n",
    "image, label = image_batch[0], label_batch[0]\n",
    "\n",
    "# View the batch shapes\n",
    "image.shape, label"
   ],
   "id": "e4997038e2b53c32",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([3, 224, 224]), tensor(0))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:03:25.907586Z",
     "start_time": "2024-08-21T07:37:46.094470Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# Plot image with matplotlib\n",
    "plt.imshow(image.permute(1, 2, 0)) # rearrange image dimensions to suit matplotlib [color_channels, height, width] -> [height, width, color_channels]\n",
    "plt.title(class_names[label])\n",
    "plt.axis(False);"
   ],
   "id": "2c1a54cd43512f06",
   "outputs": [],
   "execution_count": null
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:03:25.908586400Z",
     "start_time": "2024-08-20T14:36:41.065687Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# patch embedding layer\n",
    "# Turning a single image into patches\n",
    "# Setup hyperparameters and make sure img_size and patch_size are compatible\n",
    "# Change image shape to be compatible with matplotlib (color_channels, height, width) -> (height, width, color_channels)\n",
    "image_permuted = image.permute(1, 2, 0)\n",
    "\n",
    "# Index to plot the top row of patched pixels\n",
    "patch_size = 16\n",
    "plt.figure(figsize=(patch_size, patch_size))\n",
    "plt.imshow(image_permuted[:patch_size, :, :]);"
   ],
   "id": "2c4fae91505b7ab8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 1600x1600 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:04:55.115399Z",
     "start_time": "2024-08-21T13:04:55.101403Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Setup hyperparameters and make sure img_size and patch_size are compatible\n",
    "img_size = 224\n",
    "patch_size = 16\n",
    "num_patches = img_size/patch_size\n",
    "assert img_size % patch_size == 0, \"Image size must be divisible by patch size\"\n",
    "print(f\"Number of patches per row: {num_patches}\\nPatch size: {patch_size} pixels x {patch_size} pixels\")\n",
    "\n",
    "# Create a series of subplots\n",
    "# fig, axs = plt.subplots(nrows=1,\n",
    "#                         ncols=img_size // patch_size, # one column for each patch\n",
    "#                         figsize=(num_patches, num_patches),\n",
    "#                         sharex=True,\n",
    "#                         sharey=True)\n",
    "\n",
    "# Iterate through number of patches in the top row\n",
    "# for i, patch in enumerate(range(0, img_size, patch_size)):\n",
    "#     axs[i].imshow(image_permuted[:patch_size, patch:patch+patch_size, :]); # keep height index constant, alter the width index\n",
    "#     axs[i].set_xlabel(i+1) # set the label\n",
    "#     axs[i].set_xticks([])\n",
    "#     axs[i].set_yticks([])"
   ],
   "id": "cab7fa141d16c7a8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of patches per row: 14.0\n",
      "Patch size: 16 pixels x 16 pixels\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:03:25.909587Z",
     "start_time": "2024-08-20T14:40:18.098867Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Setup hyperparameters and make sure img_size and patch_size are compatible\n",
    "img_size = 224\n",
    "patch_size = 16\n",
    "num_patches = img_size/patch_size\n",
    "assert img_size % patch_size == 0, \"Image size must be divisible by patch size\"\n",
    "print(f\"Number of patches per row: {num_patches}\\\n",
    "        \\nNumber of patches per column: {num_patches}\\\n",
    "        \\nTotal patches: {num_patches*num_patches}\\\n",
    "        \\nPatch size: {patch_size} pixels x {patch_size} pixels\")\n",
    "\n",
    "# Create a series of subplots\n",
    "fig, axs = plt.subplots(nrows=img_size // patch_size, # need int not float\n",
    "                        ncols=img_size // patch_size,\n",
    "                        figsize=(num_patches, num_patches),\n",
    "                        sharex=True,\n",
    "                        sharey=True)\n",
    "\n",
    "# Loop through height and width of image\n",
    "for i, patch_height in enumerate(range(0, img_size, patch_size)): # iterate through height\n",
    "    for j, patch_width in enumerate(range(0, img_size, patch_size)): # iterate through width\n",
    "\n",
    "        # Plot the permuted image patch (image_permuted -> (Height, Width, Color Channels))\n",
    "        axs[i, j].imshow(image_permuted[patch_height:patch_height+patch_size, # iterate through height\n",
    "                                        patch_width:patch_width+patch_size, # iterate through width\n",
    "                                        :]) # get all color channels\n",
    "\n",
    "        # Set up label information, remove the ticks for clarity and set labels to outside\n",
    "        axs[i, j].set_ylabel(i+1,\n",
    "                             rotation=\"horizontal\",\n",
    "                             horizontalalignment=\"right\",\n",
    "                             verticalalignment=\"center\")\n",
    "        axs[i, j].set_xlabel(j+1)\n",
    "        axs[i, j].set_xticks([])\n",
    "        axs[i, j].set_yticks([])\n",
    "        axs[i, j].label_outer()\n",
    "\n",
    "# Set a super title\n",
    "fig.suptitle(f\"{class_names[label]} -> Patchified\", fontsize=16)\n",
    "plt.show()"
   ],
   "id": "17c5aebf3d32ce27",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of patches per row: 14.0        \n",
      "Number of patches per column: 14.0        \n",
      "Total patches: 196.0        \n",
      "Patch size: 16 pixels x 16 pixels\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1400x1400 with 196 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "###  利用Conv2D卷积构建patch embedding",
   "id": "6162e598987ce257"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:06:09.574824Z",
     "start_time": "2024-08-21T13:06:09.527154Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torch import nn\n",
    "\n",
    "# Set the patch size\n",
    "patch_size=16\n",
    "\n",
    "# Create the Conv2d layer with hyperparameters from the ViT paper\n",
    "conv2d = nn.Conv2d(in_channels=3, # number of color channels\n",
    "                   out_channels=768, # from Table 1: Hidden size D, this is the embedding size\n",
    "                   kernel_size=patch_size, # could also use (patch_size, patch_size)\n",
    "                   stride=patch_size,\n",
    "                   padding=0)\n",
    "\n",
    "# Pass the image through the convolutional layer\n",
    "image_out_of_conv = conv2d(image.unsqueeze(0)) # add a single batch dimension (height, width, color_channels) -> (batch, height, width, color_channels)\n",
    "print(image_out_of_conv.shape) \n",
    "# [batch_size, embedding_dim, feature_map_height, feature_map_width]"
   ],
   "id": "124c4d90b33d3b20",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1, 768, 14, 14])\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:03:25.910586500Z",
     "start_time": "2024-08-20T15:03:21.802379Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Plot random 5 convolutional feature maps\n",
    "import random\n",
    "random_indexes = random.sample(range(0, 758), k=5) # pick 5 numbers between 0 and the embedding size\n",
    "print(f\"Showing random convolutional feature maps from indexes: {random_indexes}\")\n",
    "\n",
    "# Create plot\n",
    "fig, axs = plt.subplots(nrows=1, ncols=5, figsize=(12, 12))\n",
    "\n",
    "# Plot random image feature maps\n",
    "for i, idx in enumerate(random_indexes):\n",
    "    image_conv_feature_map = image_out_of_conv[:, idx, :, :] # index on the output tensor of the convolutional layer\n",
    "    axs[i].imshow(image_conv_feature_map.squeeze().detach().numpy())\n",
    "    axs[i].set(xticklabels=[], yticklabels=[], xticks=[], yticks=[]);"
   ],
   "id": "e6abf151a1dafb12",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Showing random convolutional feature maps from indexes: [35, 61, 471, 643, 278]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1200x1200 with 5 Axes>"
      ],
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA7YAAAC0CAYAAACg2rAOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAdB0lEQVR4nO3da5Add33m8d/pPveZMxqN7qPRxbIulmWwZBtjDHgxC9hkKybYsYnJbrKLKYx3nVTYbNgkJGTDUksWWIeFgrCp3MqkMBsISUjiEMAG2yHGeDG+S7ZsoctoJI+kuWgu59rd+8KIKHnTv8fJsfQvfT9VvHt49D/d/e/u3xmKU8iyLDMAAAAAAAIVnekFAAAAAADwz8FgCwAAAAAIGoMtAAAAACBoDLYAAAAAgKAx2AIAAAAAgsZgCwAAAAAIGoMtAAAAACBoDLYAAAAAgKAVPaE0TW1iYsIajYYVCoV+rwn4R7Iss7m5ORsdHbUoevm/i+H6x5nGHsC5jOsf5zr2AM5lyvXvGmwnJiZs3bp1/yKLA16qQ4cO2djY2Mv+73L942zBHsC5jOsf5zr2AM5lnuvfNdg2Gg0zMxv96K9YVKvm5svHXLX/kJ/yf/tTSKVqK5/M3Nmop3VnsT+7uFL7hitu+7Opdrgt7vizmfjFoHIMC6nv3CSdlu2+87//6Dp8uZ36d2/4yk1WGijl5nvKhWFmY9Vpd/ah4xul7mqx684m4smuFv0n++DMsNTdbokXtaBY8t9E1C+me13hGBb896a02bb9773jjO+BsU++36JaJTdfqmg30zj2H4uLVh6RutfWZtzZauTfL2ZmxzuD7uwjx7SXwiT1X3zFWHswZtnZ8ReXesn3MOotduzhd/6fM3793/SXP2ll1zNAu5cOxP7rbkv9Bal7bWnKnd1V0brnU//nfKyzVuq+b3qbOzvTrUndkXDvVaXC3houNd3Z7kLXvnjdF8/4Htj2rg9aXM6fA6rT2j2pNO/P148sSt3R/qPubDLlfx8zMyuOrvZ3r1gqdbdW+q/ryPk+fUoa+a/TLNaeF1HPv5ZC4jvvvV7bHnrgt1zXv+vt8dT/7CCqVV2DbVTVXkrjSv8G27gsDLbiEKfML8pnNDNTRqOCOtgKS5EHW+W9XtyIZ+p//nLq3y0NlKw8WM7Pp9pgW6nlvyidUmzmDxX/KF/0n5CCeLJLQnfc0dYdRf5joopLiTurXnJp13/uCy/h5epM74GoVrGonv8MiOXB1n9jLw3k78HTVer+a6ki3u/KHf9a4gVtD5gw2CrHz+zsGWyLZW0dZ/r6LzufAZF4Ly0Lj4xqXXvg14XyhroBhMG21hb/4NH1762SsA/Nzp7Btlz2P4tOOdN7IC5XLa44ngFl7Z6kfOGsfpEXRf7ro1DQ3j2Kkf++XojF97dS/nE+JUrEwVYYBOTBVthfBXGo81z//J9HAQAAAACCxmALAAAAAAgagy0AAAAAIGgMtgAAAACAoDHYAgAAAACCxmALAAAAAAgagy0AAAAAIGjSD4utuj+2uJT/m2jq75POj/l/Iyny/Z77jyyu9ne3Vmi/pzR4QPmNUKnaEuHnruK21i0RfzJN+W3ftOgrT86S31x8bna5FXv5J+bT2+6Sem/49nvdWfX3Kgfq/ovjtq33S93D8YI7+zudN0jdR7tD7qx6TJLEv29T4bdEzcwyIV9UfsMw7t/vLipGli5YXM//jdrF+1dIvUuuPurO1uKu1P3QsY3u7MEjI1K3CfemVatmpOpUuJmqv0sbR/490+lpv8ut6Dl/B9Wb67clpaZVSvnX/91ffI3Uu/KNh93ZZqL9zuZUbcCdfXB+s9St/Gbr0uKi1F2M/PdH9Xdplbza3Un8+2W6U3Nnu8JvpPdTd8AsdbyfLq7R7knLHvfv8SzSutP1a9zZxau2SN2FzH99FOe13y1Ohd/5TsXfN446wm/NijNdWvKvpdT2dSu/03t2PC0AAAAAAHiJGGwBAAAAAEFjsAUAAAAABI3BFgAAAAAQNAZbAAAAAEDQGGwBAAAAAEFjsAUAAAAABI3BFgAAAAAQNAZbAAAAAEDQGGwBAAAAAEFjsAUAAAAABK2ohOfGIosr+bNwsaktojvgz47s6Urd05tL7uzAYXHOF+KV6Uyqbo0U3Nn5DanUPbTXv/BOQ6q20rw/u7DOt+60pX2+fpk8MWRRs5qbe2DdVql3/aopd/bozJDU3Wz7r/+Pfv8tUneyKNw+Uv/1bGYWD/Tc2e3rxqXun197jzv7356/Tuo+Nue/mW1Zftyd7S50bK+0kv6Yem7Eomr+Hki3dKTeVw0fc2cvGDwidS8kZXd2aGNL6h6rz7izI6UFqfuvD+xwZ+ea/s9oZtZd9Oc3rvOfGzOzY3OD7uz0pO8Bkza189Iv/+/4eis2K7m56pX+vW1m9rbRx9zZe49fIHXvbBxyZ6up9n51qDXizj41u0bqHir7z3maac+XqOB/H1tdPSl1TzSXuLM7h/zPrlaxa3dLK+mPYsssdhy+8kntnIzcf8CdzYaEocHM0rr/fleZ0fZAd9D/HhR3tXfZyv5Fd/b4pcNSd2nBvwdqx7Rj0lniPyYTr8t/nzAzS9pmdr+vk7/YAgAAAACCxmALAAAAAAgagy0AAAAAIGgMtgAAAACAoDHYAgAAAACCxmALAAAAAAgagy0AAAAAIGgMtgAAAACAoDHYAgAAAACCxmALAAAAAAhaUQnHbbPYkcsK2iKqU/7s9OaS1N0d8mdXPtKVuk/s8K9lcbV2UOpHM3c27mjfTyRVf7YyLVVbc7V/3clg6sqlsS/Xb9V61+J6/rH+7J7X9W0NxWIi5QsF//n4Vxufk7pnuzUp3y+dxHNX+gf/8fvvdGd7Xa07Eq7V1Pz3BCXbT5df9qyVBsq5uV6m3ZNmO/6b0n3Ht0rd5ajnzp5sCzdHM/v29HnubLsjPW6t1/Nfe0lL6371tn3u7Exb2+e9nv/cDz2Zfy2ZmSXts+MZcOPY96w2mH+sF9NK39bw5uW7pfxi6jvGZmaTnYbU/dzccnf259bfI3U/3Vrrzo7EC1L3389udmefmB6VuiPhmXvnnsvd2WSxZWZfk9bSD6P3Tlkxzr++s4L2zEpWL3Vns5L2XC4k/nPSHdDupbPn+fNqd1L133uLTana4nHhmDS0410+6X/mJmXf8yJN/evlL7YAAAAAgKAx2AIAAAAAgsZgCwAAAAAIGoMtAAAAACBoDLYAAAAAgKAx2AIAAAAAgsZgCwAAAAAIGoMtAAAAACBoDLYAAAAAgKAx2AIAAAAAgsZgCwAAAAAIWlEJj957wopxJTfXXL9EWsTkrpI7u7ixK3Uv+67/Ix64PpO6a/v92V5N655f589GF56UulsTA+7s0qe07z42fPBBd3by9itduaRTtHFpFf3xhZ1/YION/OPxQHOT1LuxdNydrRa06//mb7zXnb3vsV1Sd33XCXd2qNqWugsF/34ZKHWk7l/c8Q139vzypNT92qr//Fz0d//BnU0XW9I6+uWxr15gcaWam2vvaEq9mz7jP9+lIzNS9+6fOc+dzS6ck7r/zflPubPfmtgsdddKPXf28P7lUvf0a6ekvGLNNWvc2U2/+bgr15nv2O7PvNQV/cv53P4rLK7nvwOtaWjP5Cf2rXVnC/PSa5tVVi+6s939g1L3l2/8bXd2Js2/b5xuSey/h1Qj7bl48Je2uLNxqr27dYb877Ov/Y3d/t75ju2TVtIfh9804noGlOa043bZux91Z+8/oN1Ld4363yCf/NPtUvfIbv+1Nz+q7d3uYMGdPbnd/7wwM/vjWz/lzj7e9t+fzMzu+PRN7uyaB33Hr9ftua9//mILAAAAAAgagy0AAAAAIGgMtgAAAACAoDHYAgAAAACCxmALAAAAAAgagy0AAAAAIGgMtgAAAACAoDHYAgAAAACCxmALAAAAAAgagy0AAAAAIGhFJfzMbUMW1aq5ufJxqdYaP8j82UOx1B11/d3F4yWpOxOWMnhQqra5Tf5sZ2JA6r7wlf7FTGwckroPrbjSnY3bvlxylnz98rav/pzr+r/uiu9JvSuWnHRnH1o8X+oeWjnvzjbWO0/ID401ZtzZY81BqbsS99zZvS+skLo//s3r3dnWho7UvXrNtDt747bvu7Pt+a7dIa2kP5KymVXyc5s+47/vquZesVLK73rzbnf24QMbpO5vHNrmzv78tm9K3X94wH8v3bplQup+/mOvcWe3ffKQ1F18+qg7+8gfv9KVSzotaQ39Mvf9ZRZX858BrYXlUu+yKf9+6TYKUvdcVHdnv/2Oj0ndD7VXu7NvqU1J3ZeU97mzj3XKUvfEL/jv66t+J/98n67+sH/d41c23dle1pXW0S+tlZlF1fzrddN1/uNgZvbtcf9Lb3vSf02bmR2+c4s7W16pPbumt/nnhjUPzErdrdX+z7mwTpuNvjR7mTv7y8sflrrLt9/lzl5SHXfl5udSe9UOX+dZMjIAAAAAAPDSMNgCAAAAAILGYAsAAAAACBqDLQAAAAAgaAy2AAAAAICgMdgCAAAAAILGYAsAAAAACBqDLQAAAAAgaAy2AAAAAICgMdgCAAAAAILGYAsAAAAACFpRCVcnShZXSrm55lhXWsT8lpY72zswKHUPTBTc2c2fm5K6998w4s523nJS6i48M+TOrvt6JnUffXyjO1v/yRek7qGrJtzZqb8ddeUKqbSE/ml0zWpxbuyrz2+Xage3tt3Zbx3dInV/4MK73dlr6kel7k9P7XRnn49XSN375pa5s+97xT1S98MbznNnn55eJXX3kvzr4xTlXPYW/NdIP0Vds8jxdejhq+pS79AB/yavH9WeL8ffv8GdLb1BW/fcVv93w//r89dL3Xax/5kxE9Wk6mvf8Ig7e3d9p9R9wQf3urNL9/iu617v7Lj+R684bMWBSm5ux/ARqfeBP3yVO7vsqY7UPXrPvDt71dLbpe7/dPG33NmbDr9e6r55zXfd2b84tlPqvmXbg+7sf75zn9T9+ttvdWcbz8y4s1nSNtstLaUvNu4cd+2BXxj7utS7bqP/fvelk7uk7s1v9r/HfvgT/1bqVt5P976vLHXXH8uft05p/ECqtj/56uvc2bsqr5W6H7nxt93ZD0/61tGe75rZn7uy/MUWAAAAABA0BlsAAAAAQNAYbAEAAAAAQWOwBQAAAAAEjcEWAAAAABA0BlsAAAAAQNAYbAEAAAAAQWOwBQAAAAAEjcEWAAAAABA0BlsAAAAAQNCKSrh2LLO4nOWXLpakRTRX+Jcxuuuo1H0kWe3OHnjbiNS97Y3P+7v/5Hype+Ginjs7eal0Gq04789Gd62Suqd+fM6dbW7xfca06T8W/XTxhnErDZRzc2lWkHo///ir3NlsQTvXv/rEO/3ruHyf1N3L/N+LfWzjn0rdn4rf6M6Od7R920z896dLl49L3d88uNmdnW9W3NlkMZbW0S+lBbPYsR3ndrWk3rE3TbqzEyeHpO6r1+11Z08cOU/qbh1c6s4m1fxn5+mGv9JwZ5d9x3/8zMz2rN3hzmY/lUrdz3xgqzs78oTvXpl0tDX0y/RfrbW4XM3N/dUFa6Tey9+5x50tR9rz8O+e9d+TysWu1P3l8V3u7OqBk1L3r/39T7iz2z8uvNSY2dfK/vfCz115rdT9m//zj9zZX//Mv3dnk3bLbLe0lL54bu8ai2r5e+CWiZ+Vejf9rj975Mqa1F1s+rO1ae1eMz/mfw+KDucft9O9/qZH3NkrGs9J3S/0lrizzy7494uZ2WX33+bOXrrhoCvXbXXcnfzFFgAAAAAQNAZbAAAAAEDQGGwBAAAAAEFjsAUAAAAABI3BFgAAAAAQNAZbAAAAAEDQGGwBAAAAAEFjsAUAAAAABI3BFgAAAAAQNAZbAAAAAEDQGGwBAAAAAEErKuFC8uJ/8vTq2iKqJwru7PH710jdhcHMnY0cn+10u+/f5M52LulI3fG0/9T0av7PaGaWVIRs1X9uzMxKDwy5s9mwcw0t6TLtmxPNAStG+QevEvek3uHhBXf26h17pe5DzaXu7GhtVupeWlx0Zz9y5Fqpe7LZcGef7q2Wukuxf6OvrM5J3T+z9bvu7N8c2eHO9opte15aSX8M7+1asRTn5pY9qd03Dl2x3p1dedWE1H1h3Z8/utR//zIzO1FrubPj31krdS/7ytPubNbV7jnl6ZPu7PZPDEvdVvCf+2So6sr1ev7j3E+rH5iyYpz/DBjZPSj1Ttyz2Z299kP3Sd1vfPUed/ZYz3/fNTMreV4If2hn9aDU/bGbf8yd7Y0flroLxZI7u3q39vef/737Znd29MS0O9tL2rZbWkl/XHPJk1YezD9+qWnPgIfe738GrH/fjNSdLvEPJfHUvNRduXClOzu503/dmZm9Z7l/r6+Ku1K3kt4j7t1e5t8zlzR83a1iz/7c2clfbAEAAAAAQWOwBQAAAAAEjcEWAAAAABA0BlsAAAAAQNAYbAEAAAAAQWOwBQAAAAAEjcEWAAAAABA0BlsAAAAAQNAYbAEAAAAAQWOwBQAAAAAEraiE7/vA79tQI38WvvxXb5MWEbczd3ZxlTaLx92CO9urSdU2OO7PdmfKUvfimtSdjXpStZn/cFsmfvXRXO0vjzq+c6OuoV+OPLbaomo1Nze4fVrqHah03Nla3JW6l5YX3dm1FW3dr6j6N0CpkEjde6ZWubPdXix1t7v+29741LDUHUX+fdtcqLizabMlraNfXvjptkX1/H274RP++66Z2R/d8ll39tf3vV3q/trxC93ZZ46tlLrb7ZI7u/Vzx6Rui/3XdaGkPV8sEs5P4r+mzcws9t+w9/3EgCuXtmKzh7Vl9MMP/mvZonr+vj3/Q/NS74Fb6u7sqtKs1N2I/PeOerktdT/VHHNn3/1n75G6txx7VMorsq7/mVuI85/5p6vufcG/jpr/GVBI/Gvup/euuM8GHXPAndNXSL1LPjXkD8czUrcV/Pe7+Yv87x5mJr1PNzdo728jwvveTKq9KKemPaMVt62615390IHrXLnuQsfM7nNlz5KRAQAAAACAl4bBFgAAAAAQNAZbAAAAAEDQGGwBAAAAAEFjsAUAAAAABI3BFgAAAAAQNAZbAAAAAEDQGGwBAAAAAEFjsAUAAAAABI3BFgAAAAAQNAZbAAAAAEDQikr4ik+/2+JKNTe3uDOVFnH9VQ+5s0+8Z4fUPbWj4c4WtGVba1nBnW2PZFJ3cdHfnfmjZmZWm/T/F+Y2aQclK/o/55I9sSuXdKQl9E1166zF9VZurvnoiNQ7O+w/xh9+5Zel7l88cok7+73ZDVL3PZMXuLN7D6+UuhUF8eu5DatOuLOzd62Vupf9/oPu7N47/efmbPHW85+2ymApNzf42bbU+1N/ebs7u/2OI1L3wTdvdmcbTe0+PdwW8tGC1G3LhftIrG2C5Oln/dkLx6TufW/Pvz5O+a1rP+/KLc4ldstvSMvoi7++/Pes0cg/1nd+YZfU++zX/rU7+7v/4+1St/Keor4DKfmt/3evVl4uu6Nxw/+eZ2ZmaeKOFoR1mJmduMq/X4r/btKd7S1kZtdLS+mLX/7xd1gxruQHY9/73SnTH513Z2eOLpW6CzX/+V66dEbqblT8L6gf2XCf1L2n4/+c5YL/M5qZvaHm37x/cXKT1P17j7zOnb3gI7OuXJb4x1X+YgsAAAAACBqDLQAAAAAgaAy2AAAAAICgMdgCAAAAAILGYAsAAAAACBqDLQAAAAAgaAy2AAAAAICgMdgCAAAAAILGYAsAAAAACBqDLQAAAAAgaEUp3DKL0/zc0LPavHzPM1e4s/M3SNWWxf5scb4gdSfVzJ2NO1p3/Yi/e26jVG2ZcHqG9mrnMi35s0nVmdMOXd8UfvifPKVXzki99ThxZzd96Vape+we/3XUq2rnutPwn5ixo/7PaGZWv/dJd/bYzRdL3fsuW+3O1t46J3XPX/MKf3fcdmeTQkdaR78MFxetWszf5ItpWeq99ep73dkvbLhU6v76JR93Z3/p8LVS93cObXRnOz+r3ch2rphwZ+d6Fan7C+c96s7eOl6Tus8Xsl+avMyV6y50zOxRaR39MJ3G1k3z75NvbTwh9b7p+qf84eulavsvz93ozhYjxwveaQ5Mjrizuy/eKHVH8/6Xt2yZdn+sD/rvvb+2426peyF91J2dSgbc2dZ8zx6WVtInMyfNIsf9vSiNF7bmXT13dvmF2j1p/Gp/vvE9YWgws9Js152988SbpO7JK5e7sx/+lT+Quq+5/h3ubHyyJXVvKy64s8kS37lJev7nJ3+xBQAAAAAEjcEWAAAAABA0BlsAAAAAQNAYbAEAAAAAQWOwBQAAAAAEjcEWAAAAABA0BlsAAAAAQNAYbAEAAAAAQWOwBQAAAAAEjcEWAAAAABA0BlsAAAAAQNCKSrg0n1lcznJznaGCtorUn68d1aol4rJtVv0v+CUVf3flhNZdyD+FP5JWxO5ECDuzUmcfXbrqkJUHy7m57x5ZL/UWhBMysG5O6p57V+rOppl2PUfCumfE7vlbx9zZTm9W6h6O/Mek1SlJ3VEkbK4APTR9npU6+Xtg+5B2o65GsTt7w3mPSt13HH+NO7umol1Lb9/8mJRXlCL/je9EZ1Dqvv3wq93ZXuo/N2bafaFY8O3FzJnrtx90R6zezT8e64vTUm9s/mNWER+IH9/8RXe2m2nnOjnPf19XPqOZWcf8a0kz7W80k0nDnZ1LalK3cgxXFP3P82axJ62jb4aHzOL8F8PC/KLWW85/rvwouu8FqXrTXmHPVPzrkKXaHlj1jXF39pP3/ZjUHcf+85NVpFFRErV913WU+M8hf7EFAAAAAASNwRYAAAAAEDQGWwAAAABA0BhsAQAAAABBY7AFAAAAAASNwRYAAAAAEDQGWwAAAABA0BhsAQAAAABBY7AFAAAAAASNwRYAAAAAELSiEl5YU7C4UsjNlea1RZTmMne2syT/3z9d1PV3ZwWt24R41POvw8wsLfnLiy2pWlJItHyqXFHejyieln5ZV5uyaq2Um9u59aDU+9TCWnf2O0c2SN3dJHZnk0T7nqtS6rmzrXb+cTtdFEm3JknP/MckTbWLT7mFJD3/Z0zb4kbsk/0nllrcrObmnj26QurdsGLanX31sv1SdyJ8f7skbkrds0mtb92lyL+/ZiP/OszMeql/D9TirtTdzfzHuxL7PmNBOBb99K2T262c5t/LBuO21Lu1dtSdvaB8ROo+kQ64s8PRotTdyvz39ZL4MjFU8B/DmUy7/svCWgYi7Vwqn7ObCc8i9WWsT+YuWmHFUv4zoLigrbf+zKQ/nKRSt6X+fNbSzreioM4YJf/+KrQ6UnVWq/i7e+LxFs5PVtXeDT34iy0AAAAAIGgMtgAAAACAoDHYAgAAAACCxmALAAAAAAgagy0AAAAAIGgMtgAAAACAoDHYAgAAAACCxmALAAAAAAgagy0AAAAAIGgMtgAAAACAoBU9oSzLzMwsabdcpVFbW0TSyfzZdkHqznr+7qygdZsQV9ZhZpZm4lr6RVu2pYkQdn6tknRevO5OXYcvt1P/bnuh58o3i77cKZ2FjjubLGqbK0liIatdc0nJf7LTVip1Z9GZOdf/VJaq9wT/utOe/9ykzRfP+5neA6fWkSftad+Z9hb813W70pW6u5n/2mvFWnc7cT1CX1J3Evn3V6etdfdSbT8qusKzq+NcR3fhxc93pq//zoLvOLfFc91M/M+MhZJ27haFh3Ip0rpbmdBd0LojIb8gvXhox6SVafeykvm7laukOf9i75neA0nXNwdYTzsnvVR4t1HvX8L5zvp4byyoM4ayFvG6ELaumfAsMjOzxL/uzJntJf53oELmSI2Pj9u6detc/zjQL4cOHbKxsbGX/d/l+sfZgj2AcxnXP8517AGcyzzXv2uwTdPUJiYmrNFo6N84AP9MWZbZ3NycjY6OWhS9/P/rea5/nGnsAZzLuP5xrmMP4FymXP+uwRYAAAAAgLMV/+dRAAAAAICgMdgCAAAAAILGYAsAAAAACBqDLQAAAAAgaAy2AAAAAICgMdgCAAAAAILGYAsAAAAACNr/B3n2p92XVlm6AAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:03:25.910586500Z",
     "start_time": "2024-08-21T08:17:41.232365Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Get a single feature map in tensor form\n",
    "single_feature_map = image_out_of_conv[:, 0, :, :]\n",
    "single_feature_map, single_feature_map.requires_grad"
   ],
   "id": "227adcfec23b68f",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(tensor([[[ 2.0902e-02, -4.8634e-02, -3.5210e-01, -2.2542e-01,  1.1465e-01,\n",
       "            2.1701e-01, -3.3708e-02,  2.4262e-01,  1.9033e-01,  2.4979e-01,\n",
       "            4.9991e-02,  5.5900e-02,  9.3394e-02,  2.8140e-03],\n",
       "          [ 2.7708e-03,  9.7288e-02,  3.3937e-02,  3.5422e-02, -8.3702e-02,\n",
       "           -1.1943e-01, -2.2702e-01, -1.5857e-01, -2.5078e-01, -1.9783e-01,\n",
       "           -1.7984e-01,  2.0530e-01, -8.4790e-02,  5.9662e-02],\n",
       "          [ 3.8652e-02,  1.1064e-01, -1.4543e-01, -3.1642e-02,  4.1082e-02,\n",
       "            5.7590e-02, -3.6330e-04,  3.9325e-01, -2.8616e-02,  2.3382e-02,\n",
       "           -9.3402e-03, -2.2816e-01,  4.1836e-03,  4.9562e-02],\n",
       "          [ 8.6441e-02, -1.8102e-01, -9.2681e-02, -1.0450e-02, -1.1673e-01,\n",
       "           -1.3650e-01,  4.5666e-02,  6.4730e-02, -1.8053e-01,  1.0643e-01,\n",
       "           -1.1494e-01, -3.0973e-02, -1.0165e-04, -3.5685e-02],\n",
       "          [ 3.6746e-02,  1.2889e-02,  5.2083e-02,  2.4383e-01, -1.8799e-02,\n",
       "            1.5229e-02,  2.2244e-01, -1.8253e-01, -1.2039e-01, -2.7789e-01,\n",
       "            6.9798e-03, -6.0378e-02, -1.0996e-01,  5.4974e-02],\n",
       "          [-2.0124e-01,  1.2426e-01,  1.3629e-01, -3.4862e-01, -1.9848e-01,\n",
       "           -5.1331e-02,  7.6180e-02, -3.2498e-01, -8.0653e-02,  1.5642e-01,\n",
       "           -5.8437e-02, -7.4448e-02, -3.0780e-02,  5.9115e-02],\n",
       "          [-2.0667e-01, -4.6333e-02, -7.5385e-02, -8.2014e-02,  8.6646e-02,\n",
       "           -2.8681e-02, -2.1355e-01,  3.0202e-01,  1.1212e-01, -6.3970e-02,\n",
       "            1.9533e-01,  1.1114e-01, -1.5942e-03,  4.9443e-02],\n",
       "          [-7.2820e-02, -2.1038e-02, -1.2447e-01, -6.3692e-03,  2.0477e-01,\n",
       "            2.3172e-01,  5.8531e-02,  7.1681e-02, -2.5224e-01, -1.5118e-01,\n",
       "           -1.6499e-01, -3.3116e-01, -6.6235e-03, -7.3340e-02],\n",
       "          [-1.6912e-01, -7.8225e-02,  2.3571e-01,  4.6357e-02, -3.4154e-01,\n",
       "           -2.2241e-01, -7.5365e-02,  2.4832e-01,  4.1151e-01,  1.7746e-01,\n",
       "            5.9074e-03, -7.5064e-02,  1.7365e-01, -2.0386e-01],\n",
       "          [-1.7556e-02,  1.7870e-01, -2.7466e-01, -9.9117e-02, -8.9423e-02,\n",
       "            1.4554e-01,  8.6246e-02,  7.6493e-02, -1.4754e-01, -1.3018e-01,\n",
       "           -4.0802e-02,  1.4053e-03, -6.9801e-03, -7.2878e-02],\n",
       "          [ 9.1588e-04,  1.4224e-02,  2.7108e-01, -1.0076e-01, -1.2702e-02,\n",
       "           -2.1624e-01, -3.7089e-01, -7.7459e-02, -1.1264e-01, -3.2252e-02,\n",
       "            3.5851e-02,  1.1221e-01,  1.3160e-01, -1.4477e-01],\n",
       "          [-2.1524e-01, -8.3843e-02, -1.4554e-01, -6.4628e-04,  4.3730e-01,\n",
       "            3.6828e-01,  3.3090e-01,  2.7621e-01,  1.7036e-01,  8.1782e-02,\n",
       "            1.1316e-01, -1.3097e-01, -1.1803e-01, -8.2107e-02],\n",
       "          [ 7.5201e-02, -1.7764e-01, -2.6582e-01, -3.1423e-01, -1.9189e-01,\n",
       "           -1.7105e-01, -1.6134e-01, -5.1769e-02, -3.5747e-02, -2.5138e-02,\n",
       "           -2.7611e-01, -2.5684e-01, -1.2946e-01, -8.6333e-03],\n",
       "          [ 7.3224e-02, -3.1873e-02, -6.7868e-02, -7.8802e-02, -6.2967e-01,\n",
       "           -3.0321e-01, -4.1442e-02, -7.4712e-02, -2.2098e-01, -1.6087e-01,\n",
       "           -1.6824e-01, -1.2528e-04, -5.3577e-02, -3.4190e-02]]],\n",
       "        grad_fn=<SliceBackward>),\n",
       " True)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### flatten layer",
   "id": "715df9527f22711c"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:34:30.059488Z",
     "start_time": "2024-08-21T13:34:30.049481Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Create flatten layer\n",
    "flatten = nn.Flatten(start_dim=2, # flatten feature_map_height (dimension 2)\n",
    "                     end_dim=3) # flatten feature_map_width (dimension 3)"
   ],
   "id": "5d85519b0b36f20b",
   "outputs": [],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:34:38.365110Z",
     "start_time": "2024-08-21T13:34:38.345563Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 1. original image\n",
    "# plt.imshow(image.permute(1, 2, 0)) # adjust for matplotlib\n",
    "# plt.title(class_names[label])\n",
    "# plt.axis(False);\n",
    "print(f\"Original image shape: {image.shape}\")\n",
    "\n",
    "# 2. Turn image into feature maps\n",
    "image_out_of_conv = conv2d(image.unsqueeze(0)) # add batch dimension to avoid shape errors\n",
    "print(f\"Image feature map shape: {image_out_of_conv.shape}\")\n",
    "\n",
    "# 3. Flatten the feature maps\n",
    "image_out_of_conv_flattened = flatten(image_out_of_conv)\n",
    "print(f\"Flattened image feature map shape: {image_out_of_conv_flattened.shape}\")"
   ],
   "id": "ad357210de313514",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Original image shape: torch.Size([3, 224, 224])\n",
      "Image feature map shape: torch.Size([1, 768, 14, 14])\n",
      "Flattened image feature map shape: torch.Size([1, 768, 196])\n"
     ]
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:34:43.082731Z",
     "start_time": "2024-08-21T13:34:42.963136Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Get flattened image patch embeddings in right shape\n",
    "image_out_of_conv_flattened_reshaped = image_out_of_conv_flattened.permute(0, 2, 1) # [batch_size, P^2•C, N] -> [batch_size, N, P^2•C]\n",
    "print(f\"Patch embedding sequence shape: {image_out_of_conv_flattened_reshaped.shape} -> [batch_size, num_patches, embedding_size]\")\n",
    "\n",
    "# Get a single flattened feature map\n",
    "single_flattened_feature_map = image_out_of_conv_flattened_reshaped[:, :, 0] # index: (batch_size, number_of_patches, embedding_dimension)\n",
    "\n",
    "# Plot the flattened feature map visually\n",
    "plt.figure(figsize=(22, 22))\n",
    "plt.imshow(single_flattened_feature_map.detach().numpy())\n",
    "plt.title(f\"Flattened feature map shape: {single_flattened_feature_map.shape}\")\n",
    "plt.axis(False);"
   ],
   "id": "ee4c15a920f74b9b",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Patch embedding sequence shape: torch.Size([1, 196, 768]) -> [batch_size, num_patches, embedding_size]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 2200x2200 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 构建`PatchEmbedding`类模块化",
   "id": "d6e36ada0097b443"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:34:49.134867Z",
     "start_time": "2024-08-21T13:34:49.124918Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 1. Create a class which subclasses nn.Module\n",
    "class PatchEmbedding(nn.Module):\n",
    "    \"\"\"Turns a 2D input image into a 1D sequence learnable embedding vector.\n",
    "\n",
    "    Args:\n",
    "        in_channels (int): Number of color channels for the input images. Defaults to 3.\n",
    "        patch_size (int): Size of patches to convert input image into. Defaults to 16.\n",
    "        embedding_dim (int): Size of embedding to turn image into. Defaults to 768.\n",
    "    \"\"\"\n",
    "    # 2. Initialize the class with appropriate variables\n",
    "    def __init__(self,\n",
    "                 in_channels:int=3,\n",
    "                 patch_size:int=16,\n",
    "                 embedding_dim:int=768):\n",
    "        super().__init__()\n",
    "\n",
    "        # 3. Create a layer to turn an image into patches\n",
    "        self.patcher = nn.Conv2d(in_channels=in_channels,\n",
    "                                 out_channels=embedding_dim,\n",
    "                                 kernel_size=patch_size,\n",
    "                                 stride=patch_size,\n",
    "                                 padding=0)\n",
    "\n",
    "        # 4. Create a layer to flatten the patch feature maps into a single dimension\n",
    "        self.flatten = nn.Flatten(start_dim=2, # only flatten the feature map dimensions into a single vector\n",
    "                                  end_dim=3)\n",
    "\n",
    "    # 5. Define the forward method\n",
    "    def forward(self, x):\n",
    "        # Create assertion to check that inputs are the correct shape\n",
    "        image_resolution = x.shape[-1]\n",
    "        assert image_resolution % patch_size == 0, f\"Input image size must be divisble by patch size, image shape: {image_resolution}, patch size: {patch_size}\"\n",
    "\n",
    "        # Perform the forward pass\n",
    "        x_patched = self.patcher(x)\n",
    "        x_flattened = self.flatten(x_patched)\n",
    "        # 6. Make sure the output shape has the right order\n",
    "        return x_flattened.permute(0, 2, 1) # adjust so the embedding is on the final dimension [batch_size, P^2•C, N] -> [batch_size, N, P^2•C]"
   ],
   "id": "6232b6975bd40aa9",
   "outputs": [],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:34:58.752661Z",
     "start_time": "2024-08-21T13:34:58.687454Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# test\n",
    "set_seeds()\n",
    "\n",
    "# Create an instance of patch embedding layer\n",
    "patchify = PatchEmbedding(in_channels=3,\n",
    "                          patch_size=16,\n",
    "                          embedding_dim=768)\n",
    "\n",
    "# Pass a single image through\n",
    "print(f\"Input image shape: {image.unsqueeze(0).shape}\")\n",
    "patch_embedded_image = patchify(image.unsqueeze(0)) # add an extra batch dimension on the 0th index, otherwise will error\n",
    "print(f\"Output patch embedding shape: {patch_embedded_image.shape}\")"
   ],
   "id": "5ceef0115dcb8661",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input image shape: torch.Size([1, 3, 224, 224])\n",
      "Output patch embedding shape: torch.Size([1, 196, 768])\n"
     ]
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### [class]嵌入\n",
    "> - 将一个可学习的类标记[class]添加到patch图像块序列（向量）的前面。\n",
    "> - 在encoder输入序列的开始位置添加可学习的[class]嵌入$\\left(\\mathbf{z}_{0}^{0}=\\mathbf{x}_{\\text {class }}\\right)$向量。该[class]嵌入向量在encoder的输出端（$\\mathbf{z}_{L}^{0}$）则作为整个图像的表示（$\\mathbf{y}$）"
   ],
   "id": "be02db7eca2ee8e5"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:35:08.055610Z",
     "start_time": "2024-08-21T13:35:08.048166Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Get the batch size and embedding dimension\n",
    "batch_size = patch_embedded_image.shape[0]\n",
    "embedding_dimension = patch_embedded_image.shape[-1]\n",
    "\n",
    "# 构建与嵌入张量相同维度embedding dimension (D)的[class]可学习向量\n",
    "class_token = nn.Parameter(torch.randn(batch_size, 1, embedding_dimension), \n",
    "                           # [batch_size, number_of_tokens, embedding_dimension]\n",
    "                           requires_grad=True) # make sure the embedding is learnable\n",
    "\n",
    "# Show the first 10 examples of the class_token\n",
    "# print(class_token[:, :, :10])\n",
    "\n",
    "# Print the class_token shape\n",
    "print(f\"Class token shape: {class_token.shape} -> [batch_size, number_of_tokens, embedding_dimension]\")\n",
    "\n",
    "# Add the class token embedding to the front of the patch embedding\n",
    "patch_embedded_image_with_class_embedding = torch.cat((class_token, patch_embedded_image),\n",
    "                                                      dim=1) # concat on first dimension\n",
    "\n",
    "# Print the sequence of patch embeddings with the prepended class token embedding\n",
    "# print(patch_embedded_image_with_class_embedding)\n",
    "print(f\"Sequence of patch embeddings with class token prepended shape: {patch_embedded_image_with_class_embedding.shape} -> [batch_size, number_of_patches, embedding_dimension]\")"
   ],
   "id": "e6dcaee09cce4e6d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Class token shape: torch.Size([1, 1, 768]) -> [batch_size, number_of_tokens, embedding_dimension]\n",
      "Sequence of patch embeddings with class token prepended shape: torch.Size([1, 197, 768]) -> [batch_size, number_of_patches, embedding_dimension]\n"
     ]
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "### 构建位置嵌入",
   "id": "d32e2856cad3ed8a"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:35:20.837205Z",
     "start_time": "2024-08-21T13:35:20.816628Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Calculate N (number of patches)\n",
    "number_of_patches = int((height * width) / patch_size**2)\n",
    "\n",
    "# Get embedding dimension\n",
    "embedding_dimension = patch_embedded_image_with_class_embedding.shape[2]\n",
    "\n",
    "# Create the learnable 1D position embedding\n",
    "position_embedding = nn.Parameter(torch.ones(1,\n",
    "                                             number_of_patches+1,\n",
    "                                             embedding_dimension),\n",
    "                                  requires_grad=True) # make sure it's learnable\n",
    "\n",
    "# check the shape of the position embedding\n",
    "# print(position_embedding[:, :10, :10])\n",
    "print(f\"Position embeddding shape: {position_embedding.shape} -> [batch_size, number_of_patches, embedding_dimension]\")"
   ],
   "id": "5d9f0fd2b48ea4b6",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Position embeddding shape: torch.Size([1, 197, 768]) -> [batch_size, number_of_patches, embedding_dimension]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "### 汇总\n",
    "> 1. 设置patch_size（16）\n",
    "> 2. 获取图的height和width\n",
    "> 3. 增加一个batch维度\n",
    "> 4. 构建`PatchEmbedding`层\n",
    "> 5. 将图片输入`PatchEmbedding`层，输出一个patch embeddings序列\n",
    "> 6. 构建一个[class]类嵌入向量\n",
    "> 7. 将[class]类嵌入向量拼接到patch embeddings序列前面\n",
    "> 8. 构建一个[pos]位置嵌入向量\n",
    "> 9. 将[pos]位置嵌入向量拼接到最后：[class + patch + pos]\n"
   ],
   "id": "bd8d77b48d362685"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T13:37:05.368692Z",
     "start_time": "2024-08-21T13:37:05.341762Z"
    }
   },
   "cell_type": "code",
   "source": [
    "set_seeds()\n",
    "\n",
    "# 1. Set patch size\n",
    "patch_size = 16\n",
    "\n",
    "# 2. Print shape of original image tensor and get the image dimensions\n",
    "print(f\"Image tensor shape: {image.shape}\")\n",
    "height, width = image.shape[1], image.shape[2]\n",
    "\n",
    "# 3. Get image tensor and add batch dimension\n",
    "x = image.unsqueeze(0)\n",
    "print(f\"Input image with batch dimension shape: {x.shape}\")\n",
    "\n",
    "# 4. Create patch embedding layer\n",
    "patch_embedding_layer = PatchEmbedding(in_channels=3,\n",
    "                                       patch_size=patch_size,\n",
    "                                       embedding_dim=768)\n",
    "\n",
    "# 5. Pass image through patch embedding layer\n",
    "patch_embedding = patch_embedding_layer(x)\n",
    "print(f\"Patching embedding shape: {patch_embedding.shape}\")\n",
    "\n",
    "# 6. Create class token embedding\n",
    "batch_size = patch_embedding.shape[0]\n",
    "embedding_dimension = patch_embedding.shape[-1]\n",
    "class_token = nn.Parameter(torch.ones(batch_size, 1, embedding_dimension),\n",
    "                           requires_grad=True) # make sure it's learnable\n",
    "print(f\"Class token embedding shape: {class_token.shape}\")\n",
    "\n",
    "# 7. Prepend class token embedding to patch embedding\n",
    "patch_embedding_class_token = torch.cat((class_token, patch_embedding), dim=1)\n",
    "print(f\"Patch embedding with class token shape: {patch_embedding_class_token.shape}\")\n",
    "\n",
    "# 8. Create position embedding\n",
    "number_of_patches = int((height * width) / patch_size**2)\n",
    "position_embedding = nn.Parameter(torch.ones(1, number_of_patches+1, embedding_dimension),\n",
    "                                  requires_grad=True) # make sure it's learnable\n",
    "\n",
    "# 9. Add position embedding to patch embedding with class token\n",
    "patch_and_position_embedding = patch_embedding_class_token + position_embedding\n",
    "print(f\"Patch and position embedding shape: {patch_and_position_embedding.shape}\")"
   ],
   "id": "306453c1cc8c4316",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Image tensor shape: torch.Size([3, 224, 224])\n",
      "Input image with batch dimension shape: torch.Size([1, 3, 224, 224])\n",
      "Patching embedding shape: torch.Size([1, 196, 768])\n",
      "Class token embedding shape: torch.Size([1, 1, 768])\n",
      "Patch embedding with class token shape: torch.Size([1, 197, 768])\n",
      "Patch and position embedding shape: torch.Size([1, 197, 768])\n"
     ]
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## eq.2-multi-self attention 多头自注意力\n",
    "$$ \\begin{aligned} \\mathbf{z}_{\\ell}^{\\prime} &=\\operatorname{MSA}\\left(\\operatorname{LN}\\left(\\mathbf{z}_{\\ell-1}\\right)\\right)+\\mathbf{z}_{\\ell-1}, & & \\ell=1 \\ldots L \\end{aligned} $$\n",
    "```python\n",
    "x_output_MLP_block = MLP_layer(LN_layer(x_output_MSA_block)) + x_output_MSA_block\n",
    "```\n",
    "- **Multi-Head Self Attention (MSA)** - `torch.nn.MultiheadAttention()`\n",
    "- **Norm (LN or LayerNorm)** - `torch.nn.LayerNorm()`\n",
    "- **Residual connection** - add the input to output\n",
    "```python\n",
    "x_output_MSA_block = MSA_layer(LN_layer(x_input)) + x_input\n",
    "```"
   ],
   "id": "ec085c5490eae912"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T15:13:11.547510Z",
     "start_time": "2024-08-21T15:13:11.533689Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 1. Create a class that inherits from nn.Module\n",
    "class MultiheadSelfAttentionBlock(nn.Module):\n",
    "    \"\"\"Creates a multi-head self-attention block (\"MSA block\" for short).\n",
    "    \"\"\"\n",
    "    # 2. Initialize the class with hyperparameters from Table 1\n",
    "    def __init__(self,\n",
    "                 embedding_dim:int=768, # Hidden size D from Table 1 for ViT-Base\n",
    "                 num_heads:int=12, # Heads from Table 1 for ViT-Base\n",
    "                 attn_dropout:float=0): # doesn't look like the paper uses any dropout in MSABlocks\n",
    "        super().__init__()\n",
    "\n",
    "        # 3. Create the Norm layer (LN)\n",
    "        self.layer_norm = nn.LayerNorm(normalized_shape=embedding_dim)\n",
    "\n",
    "        # 4. Create the Multi-Head Attention (MSA) layer\n",
    "        self.multihead_attn = nn.MultiheadAttention(embed_dim=embedding_dim,\n",
    "                                                    num_heads=num_heads,\n",
    "                                                    dropout=attn_dropout,\n",
    "                                                    batch_first=True) # does our batch dimension come first?\n",
    "\n",
    "    # 5. Create a forward() method to pass the data throguh the layers\n",
    "    def forward(self, x):\n",
    "        x = self.layer_norm(x)\n",
    "        attn_output, _ = self.multihead_attn(query=x, # query embeddings\n",
    "                                             key=x, # key embeddings\n",
    "                                             value=x, # value embeddings\n",
    "                                             need_weights=False) # do we need the weights or just the layer outputs?\n",
    "        return attn_output"
   ],
   "id": "63120316c21dd7e1",
   "outputs": [],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-21T15:13:40.414957Z",
     "start_time": "2024-08-21T15:13:40.360272Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# Create an instance of MSABlock\n",
    "multihead_self_attention_block = MultiheadSelfAttentionBlock(embedding_dim=768, # from Table 1\n",
    "                                                             num_heads=12) # from Table 1\n",
    "# Pass patch and position image embedding through MSABlock\n",
    "patched_image_through_msa_block = multihead_self_attention_block(patch_and_position_embedding)\n",
    "print(f\"Input shape of MSA block: {patch_and_position_embedding.shape}\")\n",
    "print(f\"Output shape MSA block: {patched_image_through_msa_block.shape}\")"
   ],
   "id": "341a791d1019e294",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Input shape of MSA block: torch.Size([1, 197, 768])\n",
      "Output shape MSA block: torch.Size([1, 197, 768])\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "## eq.3-Multilayer Perceptron layer (MLP) 多层感知机（包含层归一和残差链接）\n",
    "\n",
    "> 原文：**The MLP contains two layers with a GELU non-linearity.**  \n",
    "> **two layers** refers to linear layers `torch.nn.Linear()`   \n",
    "> > **linear layers**线性层有时候也叫**dense layer**稠密层 或 **feedforward layer**前馈层  \n",
    "> \n",
    "> **GELU non-linearity** is the GELU (Gaussian Error Linear Units) non-linear activation function `torch.nn.GELU()`  \n",
    "\n",
    "**MLP block**: `layer norm -> linear layer -> non-linear layer -> dropout -> linear layer -> dropout`\n"
   ],
   "id": "2d6be656c0331202"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# 1. Create a class that inherits from nn.Module\n",
    "class MLPBlock(nn.Module):\n",
    "    \"\"\"Creates a layer normalized multilayer perceptron block (\"MLP block\" for short).\"\"\"\n",
    "    # 2. Initialize the class with hyperparameters from Table 1 and Table 3\n",
    "    def __init__(self,\n",
    "                 embedding_dim:int=768, # Hidden Size D from Table 1 for ViT-Base\n",
    "                 mlp_size:int=3072, # MLP size from Table 1 for ViT-Base\n",
    "                 dropout:float=0.1): # Dropout from Table 3 for ViT-Base\n",
    "        super().__init__()\n",
    "\n",
    "        # 3. Create the Norm layer (LN)\n",
    "        self.layer_norm = nn.LayerNorm(normalized_shape=embedding_dim)\n",
    "\n",
    "        # 4. Create the Multilayer perceptron (MLP) layer(s)\n",
    "        self.mlp = nn.Sequential(\n",
    "            nn.Linear(in_features=embedding_dim,\n",
    "                      out_features=mlp_size),\n",
    "            nn.GELU(), # \"The MLP contains two layers with a GELU non-linearity (section 3.1).\"\n",
    "            nn.Dropout(p=dropout),\n",
    "            nn.Linear(in_features=mlp_size, # needs to take same in_features as out_features of layer above\n",
    "                      out_features=embedding_dim), # take back to embedding_dim\n",
    "            nn.Dropout(p=dropout) # \"Dropout, when used, is applied after every dense layer..\"\n",
    "        )\n",
    "\n",
    "    # 5. Create a forward() method to pass the data throguh the layers\n",
    "    def forward(self, x):\n",
    "        x = self.layer_norm(x)\n",
    "        x = self.mlp(x)\n",
    "        return x"
   ],
   "id": "400f03c6323dca5b"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Create an instance of MLPBlock\n",
    "mlp_block = MLPBlock(embedding_dim=768, # from Table 1\n",
    "                     mlp_size=3072, # from Table 1\n",
    "                     dropout=0.1) # from Table 3\n",
    "\n",
    "# Pass output of MSABlock through MLPBlock\n",
    "patched_image_through_mlp_block = mlp_block(patched_image_through_msa_block)\n",
    "print(f\"Input shape of MLP block: {patched_image_through_msa_block.shape}\")\n",
    "print(f\"Output shape MLP block: {patched_image_through_mlp_block.shape}\")"
   ],
   "id": "6c05b77cdc875115"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "## eq.4-output 输出y（的0号索引Token，类别标签）\n",
    "\n",
    "Encoder block: `x_input -> MSA_block -> [MSA_block_output + x_input] -> MLP_block -> [MLP_block_output + MSA_block_output + x_input] -> ...`\n",
    "\n",
    "```python\n",
    "y = Linear_layer(LN_layer(x_output_MLP_block[0]))\n",
    "```\n"
   ],
   "id": "7ea6f50e8624ecec"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# 1. Create a class that inherits from nn.Module\n",
    "class TransformerEncoderBlock(nn.Module):\n",
    "    \"\"\"Creates a Transformer Encoder block.\"\"\"\n",
    "    # 2. Initialize the class with hyperparameters from Table 1 and Table 3\n",
    "    def __init__(self,\n",
    "                 embedding_dim:int=768, # Hidden size D from Table 1 for ViT-Base\n",
    "                 num_heads:int=12, # Heads from Table 1 for ViT-Base\n",
    "                 mlp_size:int=3072, # MLP size from Table 1 for ViT-Base\n",
    "                 mlp_dropout:float=0.1, # Amount of dropout for dense layers from Table 3 for ViT-Base\n",
    "                 attn_dropout:float=0): # Amount of dropout for attention layers\n",
    "        super().__init__()\n",
    "\n",
    "        # 3. Create MSA block (equation 2)\n",
    "        self.msa_block = MultiheadSelfAttentionBlock(embedding_dim=embedding_dim,\n",
    "                                                     num_heads=num_heads,\n",
    "                                                     attn_dropout=attn_dropout)\n",
    "\n",
    "        # 4. Create MLP block (equation 3)\n",
    "        self.mlp_block =  MLPBlock(embedding_dim=embedding_dim,\n",
    "                                   mlp_size=mlp_size,\n",
    "                                   dropout=mlp_dropout)\n",
    "\n",
    "    # 5. Create a forward() method\n",
    "    def forward(self, x):\n",
    "\n",
    "        # 6. Create residual connection for MSA block (add the input to the output)\n",
    "        x =  self.msa_block(x) + x\n",
    "\n",
    "        # 7. Create residual connection for MLP block (add the input to the output)\n",
    "        x = self.mlp_block(x) + x\n",
    "\n",
    "        return x"
   ],
   "id": "3d9d29bc5a781fde"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Create an instance of TransformerEncoderBlock\n",
    "transformer_encoder_block = TransformerEncoderBlock()\n",
    "\n",
    "# # Print an input and output summary of our Transformer Encoder (uncomment for full output)\n",
    "# summary(model=transformer_encoder_block,\n",
    "#         input_size=(1, 197, 768), # (batch_size, num_patches, embedding_dimension)\n",
    "#         col_names=[\"input_size\", \"output_size\", \"num_params\", \"trainable\"],\n",
    "#         col_width=20,\n",
    "#         row_settings=[\"var_names\"])"
   ],
   "id": "1652e1d9b912fdf"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Create the same as above with torch.nn.TransformerEncoderLayer()\n",
    "torch_transformer_encoder_layer = nn.TransformerEncoderLayer(d_model=768, # Hidden size D from Table 1 for ViT-Base\n",
    "                                                             nhead=12, # Heads from Table 1 for ViT-Base\n",
    "                                                             dim_feedforward=3072, # MLP size from Table 1 for ViT-Base\n",
    "                                                             dropout=0.1, # Amount of dropout for dense layers from Table 3 for ViT-Base\n",
    "                                                             activation=\"gelu\", # GELU non-linear activation\n",
    "                                                             batch_first=True, # Do our batches come first?\n",
    "                                                             norm_first=True) # Normalize first or after MSA/MLP layers?\n",
    "\n",
    "torch_transformer_encoder_layer"
   ],
   "id": "3db63b52ca95fb9c"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": [
    "# 构建ViT类\n",
    "## 全流程梳理 \n",
    "> 1. 继承`torch.nn.Module`构建`ViT`类   \n",
    "> 2. 根据`Table 1` 和 `Table 3` 提示的超参数构建 `ViT-Base` 模型  \n",
    "> 3. 确保图像尺寸能被patch_size整除  \n",
    "> 4. 通过公式$N=H W / P^{2}$计算patch数量$N$  \n",
    "> 5. 构建可学习的[class]类嵌入向量  \n",
    "> 6. 构建可学习的[pos]位置嵌入向量  \n",
    "> 7. 设置dropout嵌入层  \n",
    "> 8. 利用`PatchEmbedding`类构建patch嵌入层  \n",
    "> 9. `torch.nn.Sequential()`序列化一串`TransformerEncoderBlock`块  \n",
    "> 10. 序列化`torch.nn.LayerNorm()`和`torch.nn.Linear(out_features=num_classes)`构建MLP  \n",
    "> 11. 构建前向方法`forward()`   \n",
    "> 12. 获取输入的批大小  \n",
    "> 13. 利用8.构建patching embedding  \n",
    "> 14. 利用5.构建[class]嵌入并利用`torch.Tensor.expand()`将5.构建的向量扩展到批次数量（如果批大小为32，那么嵌入向量需要被复制或扩展32次，使每个批次都有自己的嵌入副本）  \n",
    "> 15. 利用`torch.cat()`将[class]连接到13.中表示patch嵌入的维度1  \n",
    "> 16. 将6.构建的[pos]连接到[class]和[patch]之后  \n",
    "> 17. 将[patch]和[pos]传入7.构建的dropout层  \n",
    "> 18. 将16.构建的[patch]和[pos]传入9.构建的堆叠`TransformerEncoderBlock`层  \n",
    "> 19. 将17.输出的0号索引传入10。构建的分类头  \n",
    "\n"
   ],
   "id": "218836f17e0e4d2"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# 1. Create a ViT class that inherits from nn.Module\n",
    "class ViT(nn.Module):\n",
    "    \"\"\"Creates a Vision Transformer architecture with ViT-Base hyperparameters by default.\"\"\"\n",
    "    # 2. Initialize the class with hyperparameters from Table 1 and Table 3\n",
    "    def __init__(self,\n",
    "                 img_size:int=224, # Training resolution from Table 3 in ViT paper\n",
    "                 in_channels:int=3, # Number of channels in input image\n",
    "                 patch_size:int=16, # Patch size\n",
    "                 num_transformer_layers:int=12, # Layers from Table 1 for ViT-Base\n",
    "                 embedding_dim:int=768, # Hidden size D from Table 1 for ViT-Base\n",
    "                 mlp_size:int=3072, # MLP size from Table 1 for ViT-Base\n",
    "                 num_heads:int=12, # Heads from Table 1 for ViT-Base\n",
    "                 attn_dropout:float=0, # Dropout for attention projection\n",
    "                 mlp_dropout:float=0.1, # Dropout for dense/MLP layers\n",
    "                 embedding_dropout:float=0.1, # Dropout for patch and position embeddings\n",
    "                 num_classes:int=1000): # Default for ImageNet but can customize this\n",
    "        super().__init__() # don't forget the super().__init__()!\n",
    "\n",
    "        # 3. Make the image size is divisble by the patch size\n",
    "        assert img_size % patch_size == 0, f\"Image size must be divisible by patch size, image size: {img_size}, patch size: {patch_size}.\"\n",
    "\n",
    "        # 4. Calculate number of patches (height * width/patch^2)\n",
    "        self.num_patches = (img_size * img_size) // patch_size**2\n",
    "\n",
    "        # 5. Create learnable class embedding (needs to go at front of sequence of patch embeddings)\n",
    "        self.class_embedding = nn.Parameter(data=torch.randn(1, 1, embedding_dim),\n",
    "                                            requires_grad=True)\n",
    "\n",
    "        # 6. Create learnable position embedding\n",
    "        self.position_embedding = nn.Parameter(data=torch.randn(1, self.num_patches+1, embedding_dim),\n",
    "                                               requires_grad=True)\n",
    "\n",
    "        # 7. Create embedding dropout value\n",
    "        self.embedding_dropout = nn.Dropout(p=embedding_dropout)\n",
    "\n",
    "        # 8. Create patch embedding layer\n",
    "        self.patch_embedding = PatchEmbedding(in_channels=in_channels,\n",
    "                                              patch_size=patch_size,\n",
    "                                              embedding_dim=embedding_dim)\n",
    "\n",
    "        # 9. Create Transformer Encoder blocks (we can stack Transformer Encoder blocks using nn.Sequential())\n",
    "        # Note: The \"*\" means \"all\"\n",
    "        self.transformer_encoder = nn.Sequential(*[TransformerEncoderBlock(embedding_dim=embedding_dim,\n",
    "                                                                            num_heads=num_heads,\n",
    "                                                                            mlp_size=mlp_size,\n",
    "                                                                            mlp_dropout=mlp_dropout) for _ in range(num_transformer_layers)])\n",
    "\n",
    "        # 10. Create classifier head\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.LayerNorm(normalized_shape=embedding_dim),\n",
    "            nn.Linear(in_features=embedding_dim,\n",
    "                      out_features=num_classes)\n",
    "        )\n",
    "\n",
    "    # 11. Create a forward() method\n",
    "    def forward(self, x):\n",
    "\n",
    "        # 12. Get batch size\n",
    "        batch_size = x.shape[0]\n",
    "\n",
    "        # 13. Create class token embedding and expand it to match the batch size (equation 1)\n",
    "        class_token = self.class_embedding.expand(batch_size, -1, -1) # \"-1\" means to infer the dimension (try this line on its own)\n",
    "\n",
    "        # 14. Create patch embedding (equation 1)\n",
    "        x = self.patch_embedding(x)\n",
    "\n",
    "        # 15. Concat class embedding and patch embedding (equation 1)\n",
    "        x = torch.cat((class_token, x), dim=1)\n",
    "\n",
    "        # 16. Add position embedding to patch embedding (equation 1)\n",
    "        x = self.position_embedding + x\n",
    "\n",
    "        # 17. Run embedding dropout (Appendix B.1)\n",
    "        x = self.embedding_dropout(x)\n",
    "\n",
    "        # 18. Pass patch, position and class embedding through transformer encoder layers (equations 2 & 3)\n",
    "        x = self.transformer_encoder(x)\n",
    "\n",
    "        # 19. Put 0 index logit through classifier (equation 4)\n",
    "        x = self.classifier(x[:, 0]) # run on each sample in a batch at 0 index\n",
    "\n",
    "        return x"
   ],
   "id": "48dc914b03066a7b"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Example of creating the class embedding and expanding over a batch dimension\n",
    "batch_size = 32\n",
    "class_token_embedding_single = nn.Parameter(data=torch.randn(1, 1, 768)) # create a single learnable class token\n",
    "class_token_embedding_expanded = class_token_embedding_single.expand(batch_size, -1, -1) # expand the single learnable class token across the batch dimension, \"-1\" means to \"infer the dimension\"\n",
    "\n",
    "# Print out the change in shapes\n",
    "print(f\"Shape of class token embedding single: {class_token_embedding_single.shape}\")\n",
    "print(f\"Shape of class token embedding expanded: {class_token_embedding_expanded.shape}\")"
   ],
   "id": "96dcf9cdc215af8b"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "set_seeds()\n",
    "\n",
    "# Create a random tensor with same shape as a single image\n",
    "random_image_tensor = torch.randn(1, 3, 224, 224) # (batch_size, color_channels, height, width)\n",
    "\n",
    "# Create an instance of ViT with the number of classes we're working with (pizza, steak, sushi)\n",
    "vit = ViT(num_classes=len(class_names))\n",
    "\n",
    "# Pass the random image tensor to our ViT instance\n",
    "vit(random_image_tensor)"
   ],
   "id": "3849f726b13cd1e4"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 训练模型",
   "id": "654b1bdd726de722"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "from going_modular.going_modular import engine\n",
    "\n",
    "# Setup the optimizer to optimize our ViT model parameters using hyperparameters from the ViT paper\n",
    "optimizer = torch.optim.Adam(params=vit.parameters(),\n",
    "                             lr=3e-3, # Base LR from Table 3 for ViT-* ImageNet-1k\n",
    "                             betas=(0.9, 0.999), # default values but also mentioned in ViT paper section 4.1 (Training & Fine-tuning)\n",
    "                             weight_decay=0.3) # from the ViT paper section 4.1 (Training & Fine-tuning) and Table 3 for ViT-* ImageNet-1k\n",
    "\n",
    "# Setup the loss function for multi-class classification\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "# Set the seeds\n",
    "set_seeds()\n",
    "\n",
    "# Train the model and save the training results to a dictionary\n",
    "results = engine.train(model=vit,\n",
    "                       train_dataloader=train_dataloader,\n",
    "                       test_dataloader=test_dataloader,\n",
    "                       optimizer=optimizer,\n",
    "                       loss_fn=loss_fn,\n",
    "                       epochs=10,\n",
    "                       device=device)"
   ],
   "id": "95c65e2cec63f0d3"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "# 使用预训练模型",
   "id": "53f3f685ccca73cc"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2024-08-22T02:58:41.617466Z",
     "start_time": "2024-08-22T02:58:41.613100Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# The following requires torch v0.12+ and torchvision v0.13+\n",
    "import torch\n",
    "import torchvision\n",
    "print(torch.__version__)\n",
    "print(torchvision.__version__)"
   ],
   "id": "e98635198d69f5a6",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.7.0+cu110\n",
      "0.8.1+cu110\n"
     ]
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# 1. Get pretrained weights for ViT-Base\n",
    "pretrained_vit_weights = torchvision.models.ViT_B_16_Weights.DEFAULT # requires torchvision >= 0.13, \"DEFAULT\" means best available\n",
    "\n",
    "# 2. Setup a ViT model instance with pretrained weights\n",
    "pretrained_vit = torchvision.models.vit_b_16(weights=pretrained_vit_weights).to(device)\n",
    "\n",
    "# 3. Freeze the base parameters\n",
    "for parameter in pretrained_vit.parameters():\n",
    "    parameter.requires_grad = False\n",
    "\n",
    "# 4. Change the classifier head (set the seeds to ensure same initialization with linear head)\n",
    "set_seeds()\n",
    "pretrained_vit.heads = nn.Linear(in_features=768, out_features=len(class_names)).to(device)\n",
    "# pretrained_vit # uncomment for model output"
   ],
   "id": "b38000ba992f2fe6"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# # Print a summary using torchinfo (uncomment for actual output)\n",
    "summary(model=pretrained_vit,\n",
    "        input_size=(32, 3, 224, 224), # (batch_size, color_channels, height, width)\n",
    "        # col_names=[\"input_size\"], # uncomment for smaller output\n",
    "        col_names=[\"input_size\", \"output_size\", \"num_params\", \"trainable\"],\n",
    "        col_width=20,\n",
    "        row_settings=[\"var_names\"]\n",
    ")"
   ],
   "id": "624cc3dab78d15d4"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "from helper_functions import download_data\n",
    "\n",
    "# Download pizza, steak, sushi images from GitHub\n",
    "image_path = download_data(source=\"https://github.com/mrdbourke/pytorch-deep-learning/raw/main/data/pizza_steak_sushi.zip\",\n",
    "                           destination=\"pizza_steak_sushi\")\n",
    "image_path\n",
    "\n",
    "# Setup train and test directory paths\n",
    "train_dir = image_path / \"train\"\n",
    "test_dir = image_path / \"test\"\n",
    "train_dir, test_dir"
   ],
   "id": "a5e75ff18b3ae3fc"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "'''\n",
    "if you're going to use a pretrained model, it's generally important to ensure your own custom data is transformed/formatted in the same way the data the original model was trained on.\n",
    "如果要使用预训练模型，就必须使用和原模型配套的transformed/formatted方法\n",
    "'''\n",
    "# Get automatic transforms from pretrained ViT weights\n",
    "pretrained_vit_transforms = pretrained_vit_weights.transforms()\n",
    "print(pretrained_vit_transforms)\n",
    "\n",
    "# Setup dataloaders\n",
    "train_dataloader_pretrained, test_dataloader_pretrained, class_names = data_setup.create_dataloaders(train_dir=train_dir,\n",
    "                                                                                                     test_dir=test_dir,\n",
    "                                                                                                     transform=pretrained_vit_transforms,\n",
    "                                                                                                     batch_size=32) # Could increase if we had more samples, such as here: https://arxiv.org/abs/2205.01580 (there are other improvements there too...)"
   ],
   "id": "39f5803267392cef"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 迁移学习",
   "id": "b59ec5a8a85c81e0"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "from going_modular.going_modular import engine\n",
    "\n",
    "# Create optimizer and loss function\n",
    "optimizer = torch.optim.Adam(params=pretrained_vit.parameters(),\n",
    "                             lr=1e-3)\n",
    "loss_fn = torch.nn.CrossEntropyLoss()\n",
    "\n",
    "# Train the classifier head of the pretrained ViT feature extractor model\n",
    "set_seeds()\n",
    "pretrained_vit_results = engine.train(model=pretrained_vit,\n",
    "                                      train_dataloader=train_dataloader_pretrained,\n",
    "                                      test_dataloader=test_dataloader_pretrained,\n",
    "                                      optimizer=optimizer,\n",
    "                                      loss_fn=loss_fn,\n",
    "                                      epochs=10,\n",
    "                                      device=device)\n"
   ],
   "id": "3be26f6186e173de"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 持久化",
   "id": "c1832a8ade82cede"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "# Save the model\n",
    "from going_modular.going_modular import utils\n",
    "\n",
    "utils.save_model(model=pretrained_vit,\n",
    "                 target_dir=\"models\",\n",
    "                 model_name=\"08_pretrained_vit_feature_extractor_pizza_steak_sushi.pth\")"
   ],
   "id": "a8f8106d729111bb"
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 部署",
   "id": "54c73dccd8b25ce"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "from pathlib import Path\n",
    "\n",
    "# Get the model size in bytes then convert to megabytes\n",
    "pretrained_vit_model_size = Path(\"models/08_pretrained_vit_feature_extractor_pizza_steak_sushi.pth\").stat().st_size // (1024*1024) # division converts bytes to megabytes (roughly)\n",
    "print(f\"Pretrained ViT feature extractor model size: {pretrained_vit_model_size} MB\")"
   ],
   "id": "715d3f3cfc2115b8"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "import requests\n",
    "\n",
    "# Import function to make predictions on images and plot them\n",
    "from going_modular.going_modular.predictions import pred_and_plot_image\n",
    "\n",
    "# Setup custom image path\n",
    "custom_image_path = image_path / \"04-pizza-dad.jpeg\"\n",
    "\n",
    "# Download the image if it doesn't already exist\n",
    "if not custom_image_path.is_file():\n",
    "    with open(custom_image_path, \"wb\") as f:\n",
    "        # When downloading from GitHub, need to use the \"raw\" file link\n",
    "        request = requests.get(\"https://raw.githubusercontent.com/mrdbourke/pytorch-deep-learning/main/images/04-pizza-dad.jpeg\")\n",
    "        print(f\"Downloading {custom_image_path}...\")\n",
    "        f.write(request.content)\n",
    "else:\n",
    "    print(f\"{custom_image_path} already exists, skipping download.\")\n",
    "\n",
    "# Predict on custom image\n",
    "pred_and_plot_image(model=pretrained_vit,\n",
    "                    image_path=custom_image_path,\n",
    "                    class_names=class_names)"
   ],
   "id": "f3dbc72d9da6963"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
